G80: NVIDIA GeForce 8800 GTX

DirectX 10:

Before we get on to the meaty details behind NVIDIA’s GeForce 8800-series graphics processors, we need to cover some more ground discussing some of the highlights of DirectX 10 and what they mean for gamers. DirectX 10 itself warrants an entirely separate article, so we will save most of the meat for a later time.

Since the inception of DirectX in the mid 90’s, it has become the most widely-used games development API for Microsoft’s Windows platform. Over the years though, DirectX has merely evolved with new features added on to the code based that was determined early on. DirectX 10 represents the first complete redesign since the API’s inception, and there have been many changes made to the API to make the developer’s lives much easier – we will briefly cover some of these improvements here.

Removing the CPU overhead:

Because of the way that previous versions of DirectX were written, and the hardware the API was originally written for, current versions of DirectX suffer from high CPU overheads. This is due to the fact that the CPU is used in some of the most popular commands issued to the API by the application. These overheads greatly affect the number of objects that can be rendered and the number of unique effects that can be applied to a scene. Every state change, whether it be changing textures, shaders, vertex formats or blending modes also adds even more CPU overhead, since these operations are all accessed via the API.

Essentially, these API overheads have collectively slowed down the progression towards realistic-looking games because developers have had to balance the scales between providing unique and realistic-looking objects and creating a game that performs reasonably well on a wide range of hardware. Hopefully, with DirectX 10, developers won’t have to make these kinds of compromises anymore.

Geometry Shaders & Stream Output:

The geometry shader is a new feature in DirectX 10 – it can process entire primitives as inputs and generate entire primitives as outputs. This is a change from the traditional graphics pipeline, which processed one vertex at a time in the vertex shader. In the past, it has not been possible to generate new geometry directly on the GPU. Instead, most geometry processing functions were handled by the CPU before being passed onto the GPU.

With a dedicated geometry shader, developers will be able to animate characters without having to use the CPU. Another benefit will be smoother transition of draw distances. Elder Scrolls IV: Oblivion is an excellent example here, as it is a game that suffers from some rather annoying scenery "pop-up." The current DirectX 9 implementation means that every tree needs to be created by the CPU before the vertex data and triangle set up can be processed by the GPU – this results in the trees and scenery suddenly appearing when you get within a certain distance of it.

What I envision in the future is for trees and scenery to be able to gradually fade in without pop up. Since the geometry shader is capable of generating and manipulating data without CPU intervention, it could theoretically get everything ready for the vertex shader and triangle setup portions of the unified pipeline so that the scenery can make a smooth transition from invisible to visible.

Stream output is another very important new feature included in DirectX 10. This enables data generated by the vertex or geometry shaders to be moved to memory before being sent back to the top of the pipeline to be processed again. In simple terms, it’s a mid-pipeline memory write capability. This allows for much more sophisticated rendering algorithms without having to go through every stage of the pipeline in each pass of a multiple-pass operation.

Better Instancing:

Instancing was a new feature in DirectX 9, where a single draw call from the API would send a single object to the GPU – like tree leaves, for instance. That object could be multiplied and manipulated by applying varying attributes like colour, orientation and positioning, making an entire tree. DirectX 10 improves on this significantly with a much more powerful instancing implementation – it’s now possible for developers to index values of texture arrays, render targets and even indices for different shader programmes. In simple terms, this means that instanced objects (like trees with leaves) will look even more unique than anything ever possible in DirectX 9.